using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;

namespace NewFeatures4
    {//Define interface and classes
    public interface MyInterface<out T> //Interface with out modifier
        {
        T GetItemAt(int index);
        }

    public class MyClass<T> : MyInterface<T> //Implement interface
        {
 
        public MyClass(T t1, T t2, T t3)
        {
            _data.Add(t1);
            _data.Add(t2);
            _data.Add(t3);
        }

         public T GetItemAt(int index)//Return item at index
            {//Return item of List at index
            return _data[index];
            }
        //Create List of Ts
        public List<T> _data = new List<T>();
        }

    public class FooClass<T> 
        {
        public static T GetThirdItem(MyInterface<T> foo)//Return empty list of Ts
            {
            return foo.GetItemAt(2);
            }
        }

    //The new out keyword means IEnumerable is now read only in .Net 4.0
    //public interface IEnumerable<out T> : IEnumerable //covariant
    //    {
    //    IEnumerator<T> GetEnumerator();
    //    }

    class Variance
        {
        static void Main(string[] args)
            {

            //Back to basics
            String s = "hello";
            Object o = new Object();
            o = s;
            //s = o; //Will not complile
            
            // Is a -list- of strings a -list- of objects? 
            List<String> strings = new List<String>();
            List<Object> objects = new List<Object>();
            strings.Add("hello");
            //objects = strings; //Will not complile
            //objects.Add(123);

            objects.AddRange(strings);
            objects.Add(123);
            //Add elements of objects to strings
            //This works in 4.0 as IEnumerable defined with out modifier

            MyInterface<Object> myobjects = new MyClass<Object>(1,2,3);
            MyInterface<String> mystrings = new MyClass<String>("a", "b", "c");

            o = FooClass<Object>.GetThirdItem(myobjects);
            
            o = FooClass<Object>.GetThirdItem(mystrings);
            //This works in 4.0 as MyInterface uses out modifier
           
            Console.ReadLine();
            }
        }
    }